Magnum One/Magnum One (Mid-American Digital) (Disc Manufacturing).iso/d12/clm89nov.arc/LADD.CPP

Text File | 1989-12-25 | 6KB | 276 lines

LISTING 1.
//  Module:     Containr (Abstract Base Class for Containers)
//  Version:    1.00    01-Sep-1989
//
//  Language:   C++ 2.0
//  Environ:    Any
//  Compilers:  Zortech C++
//
//  Purpose:    Provides an abstract base class for container classes.
//
//  Written by: Scott Robert Ladd
//              705 West Virginia
//              Gunnison CO 81230
//
//              MCI ID:  srl
//              FidoNet: 1:104/45.2

class Container
    {
    public:
        // store an item
        virtual int Store(void * item, unsigned int size) = 0;

        // examine an item
        virtual int Examine(void * item) = 0;

        // retrieve an item
        virtual int Retrieve(void * item) = 0;

        // return number of items in a container
        virtual unsigned long GetCount() = 0;

        // eliminate contents
        virtual void Empty() = 0;
    };

class KeyedContainer : public Container
    {
    public:
        // store an item and its key
        virtual int Store(void * key, void * item, unsigned int size) = 0;

        // examine an item
        virtual int Examine(void * key, void * item) = 0;

        // retrieve an item by key
        virtual int Remove(void * key, void * item, unsigned int size) = 0;
    };



LISTING 2.
//  Header:     SingList (Singly-Linked Lists)
//  Version:    1.00     01-Sep-1989
//
//  Language:   C++ 2.0
//  Environ:    Any
//  Compilers:  Zortech C++
//
//  Purpose:    Provides a general set of singly-linked list classes
//
//  Written by: Scott Robert Ladd
//              705 West Virginia
//              Gunnison CO 81230
//
//              MCI ID:  srl
//              FidoNet: 1:104/45.2

#include "containr.hpp"

class SinglyLinkedList : public Container
    {
    protected:
        // structure of a node in a list
        struct ListNode
            {
            ListNode  *  Next;
            void      *  DataPtr;
            unsigned int DataLen;
            };

        ListNode * Head;  // pointer to first node
        ListNode * Tail;  // pointer to the last node

        unsigned long Count; // number of nodes in list

    public:
        // constructor
        SinglyLinkedList();

        // destructor
        ~SinglyLinkedList();

        // obtain list size method
        virtual unsigned long GetCount()
            {
            return Count;
            }

        // remove all items from a list
        virtual void Empty();
    };

class Stack : public SinglyLinkedList
    {
    public:
        // store an item in a stack
        virtual int Store(void * item, unsigned int size);

        // examine the top item in the stack
        virtual int Examine(void * item);

        // retrieve the top item in a stack (and remove it)
        virtual int Retrieve(void * item);
    };

class Queue : public Stack
    {
    public:
        // store an item in a queue
        virtual int Store(void * item, unsigned int size);
    };



LISTING 3.
//  Module:     SingList (Singly-Linked Lists)
//  Version:    1.00     01-Sep-1989
//
//  Language:   C++ 2.0
//  Environ:    Any
//  Compilers:  Zortech C++
//
//  Purpose:    Provides a general set of singly-linked list classes
//
//  Written by: Scott Robert Ladd
//              705 West Virginia
//              Gunnison CO 81230
//
//              MCI ID:  srl
//              FidoNet: 1:104/45.2

#include "singlist.hpp"
#include "stddef.h"
#include "string.h"

//-----------------------//
// SinglyLinkedList methods //
//-----------------------//

// constructor
SinglyLinkedList::SinglyLinkedList()
    {
    Head  = NULL;
    Tail  = NULL;
    Count = 0;
    }

// destructor
SinglyLinkedList::~SinglyLinkedList()
    {
    this->Empty();
    }

void SinglyLinkedList::Empty()
    {
    ListNode * temp;

    temp = Head;

    while (temp != NULL)
        {
        delete temp;
        temp = temp->Next;
        }
    }

//---------------//
// Stack methods //
//---------------//

// add new item
int Stack::Store(void * item, unsigned size)
    {
    ListNode * new_node;

    new_node = new ListNode;

    if (NULL == new_node)
        return 1;

    new_node->Next    = Head;
    new_node->DataPtr = new char[size];
    new_node->DataLen = size;

    memcpy(new_node->DataPtr,item,size);

    Head = new_node;

    if (Tail == NULL)
        Tail = new_node;

    ++Count;

    return 0;
    }

// examine the top item on the stack
int Stack::Examine(void * item)
    {
    if (Count == 0)
        return 1;

    memcpy(item,Head->DataPtr,Head->DataLen);

    return 0;
    }

// read and remove the top item on the stack
int Stack::Retrieve(void * item)
    {
    ListNode * temp;

    if (Count == 0)
        return 1;

    temp = Head->Next;

    memcpy(item,Head->DataPtr,Head->DataLen);

    delete Head->DataPtr;
    delete Head;

    Head = temp;

    --Count;

    return 0;
    }

//---------------//
// Queue methods //
//---------------//

// add new item
int Queue::Store(void * item, unsigned int size)
    {
    ListNode * new_node;

    new_node = new ListNode;

    if (NULL == new_node)
        return 1;

    new_node->Next     = NULL;
    new_node->DataPtr = new char[size];
    new_node->DataLen = size;

    memcpy(new_node->DataPtr,item,size);

    if (Count > 0)
        {
        Tail->Next = new_node;
        Tail       = new_node;
        }
    else
        {
        Head = new_node;
        Tail = new_node;
        }

    ++Count;

    return 0;
    }